var netpkg = {
	/**
	 * [read_pkg_size 读取消息前面2个字节存储的长度信息]
	 * @param  {[type]} pkg_data [数据包]
	 * @param  {[type]} offset   [从哪里开始读取]
	 * @return {[type]}          [description]
	 */
	read_pkg_size:function(pkg_data, offset){
		//数据格式 = 2个字节的包体长度 + 数据
		//当前数据不够一个完整的数据格式
		if (offset > pkg_data.length - 2) { // 没有办法获取长度信息的;
			return -1; 
		}

		// 读取长度信息，2个字节是 Uint16
		var len = pkg_data.readUInt16LE(offset);
		return len;
	},


	/**
	 * 	把一个要发送的数据,封包 2个字节的长度 + 数据
		data string 二进制的buffer
		打包数据
	 * @param {*} data 
	 * @returns 
	 */
	package_data: function(data) {
		var buf = Buffer.allocUnsafe(2 + data.length);
		buf.writeInt16LE(2 + data.length, 0);
		buf.fill(data, 2);

		return buf;
	},

	//解包数据
	unpack_cmd_from_data: function(client_sock, data) {
		var last_pkg = client_sock.last_pkg;
		var cmd_set = [];
		 if(last_pkg !== null){//表示上一次有未完成的数据
            //把上次未完成的包和本次的数据包合并成一个buf
            var buf = Buffer.concat([last_pkg,data],last_pkg.length + data.length);
            last_pkg = buf;
        }else{
            last_pkg = data;
        }

        var offset = 0;
        var pkg_len = netpkg.read_pkg_size(last_pkg, offset);
        if (pkg_len < 0) {
            return last_pkg;
        }

        console.log('====pkg_len===',pkg_len,last_pkg.length);
        while(offset + pkg_len <= last_pkg.length) { // 判断是否有完整的包;
            // 根据长度信息来读取我们的数据,架设我们穿过来的是文本数据
            // 分配数据的buf内存
            var cmd_buf = Buffer.allocUnsafe(pkg_len - 2); // 2个长度信息
            cmd_set.push(cmd_buf);
            //从第2个字节开始拷贝数据
            //拷贝的是实时的数据， 不算前面2个字节的包体长度
            last_pkg.copy(cmd_buf, 0, offset + 2, offset + pkg_len);

            console.log("recv Cmd: ", cmd_buf); // cmdbuf ,用户发过来的命令的数据;
            console.log(cmd_buf.toString("utf8"));

            offset += pkg_len;
            if (offset >= last_pkg.length) { // 正好我们的包处理完了;
                break;
            }

            pkg_len = netpkg.read_pkg_size(last_pkg, offset);
            if (pkg_len < 0) {
                break;
            }
        }

        // 能处理的数据包已经处理完成了,保存 0.几个包的数据
        if (offset >= last_pkg.length) {
            last_pkg = null;
        }
        else { // offset, length这段数据拷贝到新的Buffer里面
            //保留无法处理的半个数据包，用于下个消息处理
            var buf = Buffer.allocUnsafe(last_pkg.length - offset);
            last_pkg.copy(buf, 0, offset, last_pkg.length);
            last_pkg = buf;
            console.log('============有半个无法处理===========')
        }
        client_sock.last_pkg = last_pkg;
        // end 
		return cmd_set;
	},

	// 模拟底层TCP 粘包的问题
	test_pkg_two_action: function(action1, action2) {
		var buf = Buffer.allocUnsafe(2 + 2 + action1.length + action2.length);
		buf.writeInt16LE(2 + action1.length, 0);
		buf.fill(action1, 2);

		var offset = 2 + action1.length;
		buf.writeInt16LE(2 + action2.length, offset);
		buf.fill(action2, offset + 2);

		return buf
	},

	// 模拟的一个大的数据包，分两次发送到客户端;
	// one cmd half_cmd + half_cmd2
	test_pkg_two_slice: function(half_cmd1, half_cmd2) {
		// 
		var buf1 = Buffer.allocUnsafe(2 + half_cmd1.length);
		buf1.writeInt16LE(2 + half_cmd1.length +　half_cmd2.length, 0);
		buf1.fill(half_cmd1, 2);

		var buf2 = Buffer.allocUnsafe(half_cmd2.length);
		buf2.fill(half_cmd2, 0);

		return [buf1, buf2];
	}
}
module.exports = netpkg;